// Copyright(c) 2018-2022, Intel Corporation
//
// Redistribution  and  use  in source  and  binary  forms,  with  or  without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of  source code  must retain the  above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
// * Neither the name  of Intel Corporation  nor the names of its contributors
//   may be used to  endorse or promote  products derived  from this  software
//   without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE
// IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE
// LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR
// CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF
// SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS
// INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN
// CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif // HAVE_CONFIG_H

#include <limits.h>

#define NO_OPAE_C
#include "mock/opae_fixtures.h"

#define ARRAY_SIZE(a) (sizeof(a)/sizeof(*a))

extern "C" {

typedef fpga_result (*filter_fn)(fpga_properties *, int, char **);
typedef fpga_result (*command_fn)(fpga_token *, int, int, char **);
typedef void (*help_fn)(void);

typedef enum metrics_inquiry { FPGA_ALL, FPGA_POWER, FPGA_THERMAL } metrics_inquiry;

struct command_handler {
    const char *command;
    filter_fn filter;
    command_fn run;
    help_fn help;
};
extern struct command_handler *cmd_array;

void help(void);

int parse_args(int argc, char *argv[]);

struct command_handler *get_command(char *cmd);

fpga_result errors_filter(fpga_properties *filter, int argc, char *argv[]);

fpga_result errors_command(fpga_token *tokens, int num_tokens, int argc,
			   char *argv[]);
void errors_help(void);

fpga_result fme_filter(fpga_properties *filter, int argc, char *argv[]);

fpga_result fme_command(fpga_token *tokens, int num_tokens, int argc,
			char *argv[]);
void fme_help(void);

void fpgainfo_print_common(const char *hdr, fpga_properties props);

void fpgainfo_print_err(const char *s, fpga_result res);

fpga_result port_filter(fpga_properties *filter, int argc, char *argv[]);

fpga_result port_command(fpga_token *tokens, int num_tokens, int argc,
			 char *argv[]);
void port_help(void);

fpga_result power_filter(fpga_properties *filter, int argc, char *argv[]);

fpga_result power_command(fpga_token *tokens, int num_tokens, int argc,
			  char *argv[]);
void power_help(void);

fpga_result temp_filter(fpga_properties *filter, int argc, char *argv[]);

fpga_result temp_command(fpga_token *tokens, int num_tokens, int argc,
			 char *argv[]);
void temp_help(void);

fpga_result bmc_filter(fpga_properties *filter, int argc, char *argv[]);

fpga_result bmc_command(fpga_token *tokens, int num_tokens, int argc,
			 char *argv[]);
void bmc_help(void);

fpga_result events_filter(fpga_properties *filter, int argc, char *argv[]);
fpga_result events_command(fpga_token *tokens, int num_tokens, int argc,
        char *argv[]);
void events_help(void);


fpga_result get_metrics(fpga_token token, metrics_inquiry inquiry,
                        fpga_metric_info *metrics_info, uint64_t *num_metrics_info,
                        fpga_metric *metrics,uint64_t *num_metrics);

void replace_chars(char *str, char match, char rep);

void upcase_pci(char *str);

void upcase_first(char *str);

int str_in_list(const char *key, const char *list[], size_t size);

int fpgainfo_main(int argc, char *argv[]);

int parse_error_args(int argc, char *argv[]);

}

using namespace opae::testing;

class fpgainfo_c_p : public opae_base_p<> {
 protected:

  virtual void SetUp() override
  {
    opae_base_p<>::SetUp();
    optind = 0;
  }
};

/**
 * @test       get_command0
 * @brief      Test: get_command
 * @details    When passed with valid commands, the fn <br>
 *             returns non-nullptr <br>
 */
TEST_P(fpgainfo_c_p, get_command0) {
  char cmd[20];

  strcpy(cmd, "errors");
  EXPECT_NE(get_command(cmd), nullptr);

  strcpy(cmd, "power");
  EXPECT_NE(get_command(cmd), nullptr);

  strcpy(cmd, "temp");
  EXPECT_NE(get_command(cmd), nullptr);

  strcpy(cmd, "fme");
  EXPECT_NE(get_command(cmd), nullptr);

  strcpy(cmd, "port");
  EXPECT_NE(get_command(cmd), nullptr);

  /*
  strcpy(cmd, "bmc");
  EXPECT_NE(get_command(cmd), nullptr);
  */
}

/**
 * @test       get_command1
 * @brief      Test: get_command
 * @details    When passed with invalid commands, the fn <br>
 *             returns nullptr <br>
 */
TEST_P(fpgainfo_c_p, get_command1) {
  char cmd[20];

  strcpy(cmd, "???");
  EXPECT_EQ(get_command(cmd), nullptr);
}


/**
 * @test       errors_filter0
 * @brief      Test: errors_filter
 * @details    When passed with valid arguments, the function <br>
 *             returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, errors_filter0) {
  char zero[20];
  char one[20];
  char two[20];
  char three[20];
  char *argv3[] = { zero, one, two, NULL };
  char *argv4[] = { zero, one, two, three, NULL };

  fpga_properties filter = NULL;
  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "errors");
  strcpy(two, "fme");
  EXPECT_EQ(errors_filter(&filter, 3, argv3), FPGA_OK);

  strcpy(two, "port");
  EXPECT_EQ(errors_filter(&filter, 3, argv3), FPGA_OK);

  strcpy(two, "all");
  EXPECT_EQ(errors_filter(&filter, 3, argv3), FPGA_OK);

  strcpy(two, "fme");
  strcpy(three, "-c");
  EXPECT_EQ(errors_filter(&filter, 4, argv4), FPGA_OK);

  strcpy(two, "port");
  EXPECT_EQ(errors_filter(&filter, 4, argv4), FPGA_OK);

  strcpy(two, "all");
  EXPECT_EQ(errors_filter(&filter, 4, argv4), FPGA_OK);

  strcpy(two, "fme");
  strcpy(three, "--force");
  EXPECT_EQ(errors_filter(&filter, 4, argv4), FPGA_OK);

  strcpy(two, "port");
  EXPECT_EQ(errors_filter(&filter, 4, argv4), FPGA_OK);

  strcpy(two, "all");
  EXPECT_EQ(errors_filter(&filter, 4, argv4), FPGA_OK);

  ASSERT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);
}

/**
 * @test       errors_command0
 * @brief      Test: errors_command
 * @details    When passed with valid arguments, the fn prints <br>
 *             relevant information and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, errors_command0) {
  char zero[20];
  char one[20];
  char two[20];
  char three[20];
  char *argv3[] = { zero, one, two, NULL };
  char *argv4[] = { zero, one, two, three, NULL };

  fpga_properties filter = NULL;
  fpga_token *tokens = NULL;
  uint32_t matches = 0, num_tokens = 0;;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, NULL, 0, &matches), FPGA_OK);
  ASSERT_GT(matches, 0);
  tokens = (fpga_token *)opae_malloc(matches * sizeof(fpga_token));

  num_tokens = matches;
  ASSERT_EQ(fpgaEnumerate(&filter, 1, tokens, num_tokens, &matches), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "errors");
  strcpy(two, "all");
  EXPECT_EQ(errors_command(tokens, num_tokens, 3, argv3), FPGA_OK);

  strcpy(two, "fme");
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  EXPECT_EQ(errors_command(tokens, num_tokens, 3, argv3), FPGA_OK);

  strcpy(two, "port");
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_ACCELERATOR), FPGA_OK);
  EXPECT_EQ(errors_command(tokens, num_tokens, 3, argv3), FPGA_OK);

  strcpy(two, "all");
  strcpy(three, "-h");
  EXPECT_EQ(errors_command(tokens, num_tokens, 4, argv4), FPGA_OK);

  strcpy(two, "fme");
  strcpy(three, "-h");
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  EXPECT_EQ(errors_command(tokens, num_tokens, 4, argv4), FPGA_OK);

  strcpy(two, "port");
  strcpy(three, "-h");
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_ACCELERATOR), FPGA_OK);
  EXPECT_EQ(errors_command(tokens, num_tokens, 4, argv4), FPGA_OK);

  strcpy(two, "all");
  strcpy(three, "-c");
  EXPECT_EQ(errors_command(tokens, num_tokens, 4, argv4), FPGA_OK);

  strcpy(two, "fme");
  strcpy(three, "-c");
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  EXPECT_EQ(errors_command(tokens, num_tokens, 4, argv4), FPGA_OK);

  strcpy(two, "port");
  strcpy(three, "-c");
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_ACCELERATOR), FPGA_OK);
  EXPECT_EQ(errors_command(tokens, num_tokens, 4, argv4), FPGA_OK);

  strcpy(two, "all");
  strcpy(three, "--force");
  EXPECT_EQ(errors_command(tokens, num_tokens, 4, argv4), FPGA_OK);

  strcpy(two, "fme");
  strcpy(three, "--force");
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  EXPECT_EQ(errors_command(tokens, num_tokens, 4, argv4), FPGA_OK);

  strcpy(two, "port");
  strcpy(three, "--force");
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_ACCELERATOR), FPGA_OK);
  EXPECT_EQ(errors_command(tokens, num_tokens, 4, argv4), FPGA_OK);

  for (uint32_t i = 0; i < num_tokens; ++i) {
      fpgaDestroyToken(&tokens[i]);
  }
  opae_free(tokens);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       parse_error_args_errors_clear
 * @brief      Test: parse_error_args
 * @details    When passed the clear errors option, the function <br>
 *             prints and clears errors.<br>
 */
TEST_P(fpgainfo_c_p, parse_error_args_errors_clear) {
  char zero[20];
  char one[20];
  char two[20];
  char three[20];
  char *argv[] = { zero, one, two, three, NULL };

  fpga_properties filter = NULL;
  fpga_token *tokens = NULL;
  uint32_t matches = 0, num_tokens = 0;;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, NULL, 0, &matches), FPGA_OK);
  ASSERT_GT(matches, 0);
  tokens = (fpga_token *)opae_malloc(matches * sizeof(fpga_token));

  num_tokens = matches;
  ASSERT_EQ(fpgaEnumerate(&filter, 1, tokens, num_tokens, &matches), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "errors");
  strcpy(two, "all");
  strcpy(three, "-c");
  EXPECT_EQ(parse_error_args(4, argv), 0);

  EXPECT_EQ(errors_command(tokens, num_tokens, 4, argv), FPGA_OK);

  for (uint32_t i = 0; i < num_tokens; ++i) {
    fpgaDestroyToken(&tokens[i]);
  }
  opae_free(tokens);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       parse_error_args_neg
 * @brief      Test: parse_error_args
 * @details    When passed an invalid option, the function prints <br>
 *             help message for errors subcommand and returns
 *             an error.<br>
 */
TEST_P(fpgainfo_c_p, parse_error_args_neg) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  strcpy(zero, "fpgainfo");
  strcpy(one, "-k");
  EXPECT_NE(parse_error_args(2, argv), 0);
}

/**
 * @test       errors_help
 * @brief      Test: errors_help
 * @details    The function prints help message for errors <br>
 *             subcommand.<br>
 */
TEST_P(fpgainfo_c_p, errors_help) {
  errors_help();
}

/**
 * @test       parse_error_args_help
 * @brief      Test: parse_error_args
 * @details    When passed the help option, the function prints <br>
 *             help message for errors subcommand.<br>
 */
TEST_P(fpgainfo_c_p, parse_error_args_help) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  std::string expected = "\nPrint and clear errors\n"
                    "        fpgainfo errors [-h] [-c] {all,fme,port}\n\n"
                    "                -h,--help           Print this help\n"
                    "                -c,--clear          Clear all errors\n"
                    "                --force             Retry clearing errors 64 times\n"
                    "                                    to clear certain error conditions\n"
                    "\n";

  strcpy(zero, "fpgainfo");
  strcpy(one, "-h");

  testing::internal::CaptureStdout();

  EXPECT_NE(parse_error_args(2, argv), 0);

  std::string log_stdout = testing::internal::GetCapturedStdout();

  EXPECT_TRUE(log_stdout.find(expected) != std::string::npos);
}

/**
 * @test       errors_filter1
 * @brief      Test: errors_filter
 * @details    When passed with invalid arguments, the function <br>
 *             prints help message and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, errors_filter1) {
  char zero[20];
  char one[20];
  char two[20];
  char *argv[] = { zero, one, two, NULL };

  fpga_properties filter = NULL;
  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "errors");
  strcpy(two, "???");
  EXPECT_EQ(errors_filter(&filter, 3, argv), FPGA_OK);

  ASSERT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);
}

/**
 * @test       errors_filter2
 * @brief      Test: errors_filter
 * @details    When passed with argument that requires additional <br>
 *             option, missing the option causes the fn to print <br>
 *             help messages and return FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, errors_filter2) {
  char zero[20];
  char one[20];
  char two[20];
  char *argv2[] = { zero, one, NULL };
  char *argv3[] = { zero, one, two, NULL };

  fpga_properties filter = NULL;
  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "errors");
  EXPECT_EQ(errors_filter(&filter, 2, argv2), FPGA_OK);

  strcpy(two, "-c");
  EXPECT_EQ(errors_filter(&filter, 3, argv3), FPGA_OK);

  strcpy(two, "--force");
  EXPECT_EQ(errors_filter(&filter, 3, argv3), FPGA_OK);

  ASSERT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);
}

/**
 * @test       fme_filter0
 * @brief      Test: fme_filter
 * @details    When passed with valid arguments, the function <br>
 *             returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, fme_filter0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  fpga_properties filter = NULL;
  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "fme");
  EXPECT_EQ(fme_filter(&filter, 2, argv), FPGA_OK);
  ASSERT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);
}

/**
 * @test       fme_command0
 * @brief      Test: fme_command
 * @details    When passed with valid arguments, the fn prints <br>
 *             relevant information and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, fme_command0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  fpga_properties filter = NULL;
  fpga_token *tokens = NULL;
  uint32_t matches = 0, num_tokens = 0;;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, NULL, 0, &matches), FPGA_OK);
  ASSERT_GT(matches, 0);
  tokens = (fpga_token *)opae_malloc(matches * sizeof(fpga_token));

  num_tokens = matches;
  ASSERT_EQ(fpgaEnumerate(&filter, 1, tokens, num_tokens, &matches), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "fme");
  EXPECT_EQ(fme_command(tokens, num_tokens, 2, argv), FPGA_OK);

  for (uint32_t i = 0; i < num_tokens; ++i) {
    fpgaDestroyToken(&tokens[i]);
  }
  opae_free(tokens);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       fme_command1
 * @brief      Test: fme_command
 * @details    When passed with '-h', the fn prints <br>
 *             fme help message and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, fme_command1) {
  char zero[20];
  char one[20];
  char two[20];
  char *argv[] = { zero, one, two, NULL };

  fpga_token *tokens = NULL;

  strcpy(zero, "fpgainfo");
  strcpy(one, "fme");
  strcpy(two, "-h");
  EXPECT_EQ(fme_command(tokens, 0, 3, argv), FPGA_OK);
}

/**
 * @test       fme_help
 * @brief      Test: fme_help
 * @details    The function prints help message for fme subcommand.<br>
 */
TEST_P(fpgainfo_c_p, fme_help) {
  fme_help();
}

/**
 * @test       port_filter0
 * @brief      Test: port_filter
 * @details    When passed with valid arguments, the function <br>
 *             returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, port_filter0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  fpga_properties filter = NULL;
  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "port");
  EXPECT_EQ(port_filter(&filter, 2, argv), FPGA_OK);
  ASSERT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);
}

/**
 * @test       port_command0
 * @brief      Test: port_command
 * @details    When passed with valid arguments, the fn prints <br>
 *             relevant information and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, port_command0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  fpga_properties filter = NULL;
  fpga_token *tokens = NULL;
  uint32_t matches = 0, num_tokens = 0;;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_ACCELERATOR), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, NULL, 0, &matches), FPGA_OK);
  ASSERT_GT(matches, 0);
  tokens = (fpga_token *)opae_malloc(matches * sizeof(fpga_token));

  num_tokens = matches;
  ASSERT_EQ(fpgaEnumerate(&filter, 1, tokens, num_tokens, &matches), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "port");
  EXPECT_EQ(port_command(tokens, num_tokens, 2, argv), FPGA_OK);

  for (uint32_t i = 0; i < num_tokens; ++i) {
    fpgaDestroyToken(&tokens[i]);
  }
  opae_free(tokens);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       port_command1
 * @brief      Test: port_command
 * @details    When passed with '-h', the fn prints <br>
 *             port help message and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, port_command1) {
  char zero[20];
  char one[20];
  char two[20];
  char *argv[] = { zero, one, two, NULL };

  fpga_token *tokens = NULL;

  strcpy(zero, "fpgainfo");
  strcpy(one, "port");
  strcpy(two, "-h");
  EXPECT_EQ(port_command(tokens, 0, 3, argv), FPGA_OK);
}

/**
 * @test       port_help
 * @brief      Test: port_help
 * @details    The function prints help message for port subcommand.<br>
 */
TEST_P(fpgainfo_c_p, port_help) {
  port_help();
}

/**
 * @test       power_filter0
 * @brief      Test: power_filter
 * @details    When passed with valid arguments, the function <br>
 *             returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, power_filter0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  fpga_properties filter = NULL;
  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "power");
  EXPECT_EQ(power_filter(&filter, 2, argv), FPGA_OK);
  ASSERT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);
}

/**
 * @test       power_command0
 * @brief      Test: power_command
 * @details    When passed with valid arguments, the fn prints <br>
 *             relevant information and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, power_command0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  fpga_properties filter = NULL;
  fpga_token *tokens = NULL;
  uint32_t matches = 0, num_tokens = 0;;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, NULL, 0, &matches), FPGA_OK);
  ASSERT_GT(matches, 0);
  tokens = (fpga_token *)opae_malloc(matches * sizeof(fpga_token));

  num_tokens = matches;
  ASSERT_EQ(fpgaEnumerate(&filter, 1, tokens, num_tokens, &matches), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "power");
  EXPECT_EQ(power_command(tokens, num_tokens, 2, argv), FPGA_OK);

  for (uint32_t i = 0; i < num_tokens; ++i) {
    fpgaDestroyToken(&tokens[i]);
  }
  opae_free(tokens);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       power_command1
 * @brief      Test: power_command
 * @details    When passed with '-h', the fn prints <br>
 *             power help message and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, power_command1) {
  char zero[20];
  char one[20];
  char two[20];
  char *argv[] = { zero, one, two, NULL };

  fpga_token *tokens = NULL;

  strcpy(zero, "fpgainfo");
  strcpy(one, "power");
  strcpy(two, "-h");
  EXPECT_EQ(power_command(tokens, 0, 3, argv), FPGA_OK);
}

/**
 * @test       power_help
 * @brief      Test: power_help
 * @details    The function prints help message for power subcommand.<br>
 */
TEST_P(fpgainfo_c_p, power_help) {
  power_help();
}

/**
 * @test       temp_filter0
 * @brief      Test: temp_filter
 * @details    When passed with valid arguments, the function <br>
 *             returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, temp_filter0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  fpga_properties filter = NULL;
  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "temp");
  EXPECT_EQ(temp_filter(&filter, 2, argv), FPGA_OK);
  ASSERT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);
}

/**
 * @test       temp_command0
 * @brief      Test: temp_command
 * @details    When passed with valid arguments, the fn prints <br>
 *             relevant information and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, temp_command0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  fpga_properties filter = NULL;
  fpga_token *tokens = NULL;
  uint32_t matches = 0, num_tokens = 0;;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, NULL, 0, &matches), FPGA_OK);
  ASSERT_GT(matches, 0);
  tokens = (fpga_token *)opae_malloc(matches * sizeof(fpga_token));

  num_tokens = matches;
  ASSERT_EQ(fpgaEnumerate(&filter, 1, tokens, num_tokens, &matches), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "temp");
  EXPECT_EQ(temp_command(tokens, num_tokens, 2, argv), FPGA_OK);

  for (uint32_t i = 0; i < num_tokens; ++i) {
    fpgaDestroyToken(&tokens[i]);
  }
  opae_free(tokens);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       temp_command1
 * @brief      Test: temp_command
 * @details    When passed with '-h', the fn prints <br>
 *             temp help message and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, temp_command1) {
  char zero[20];
  char one[20];
  char two[20];
  char *argv[] = { zero, one, two, NULL };

  fpga_token *tokens = NULL;

  strcpy(zero, "fpgainfo");
  strcpy(one, "temp");
  strcpy(two, "-h");
  EXPECT_EQ(temp_command(tokens, 0, 3, argv), FPGA_OK);
}

/**
 * @test       temp_help
 * @brief      Test: temp_help
 * @details    The function prints help message for temp subcommand.<br>
 */
TEST_P(fpgainfo_c_p, temp_help) {
  temp_help();
}

/**
 * @test       bmc_filter0
 * @brief      Test: bmc_filter
 * @details    When passed with valid arguments, the function <br>
 *             returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, bmc_filter0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  fpga_properties filter = NULL;
  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "bmc");
  EXPECT_EQ(bmc_filter(&filter, 2, argv), FPGA_OK);
  ASSERT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);
}

/**
 * @test       bmc_command0
 * @brief      Test: bmc_command
 * @details    When passed with valid arguments, the fn prints <br>
 *             relevant information and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, bmc_command0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  fpga_properties filter = NULL;
  fpga_token *tokens = NULL;
  uint32_t matches = 0, num_tokens = 0;;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, NULL, 0, &matches), FPGA_OK);
  ASSERT_GT(matches, 0);
  tokens = (fpga_token *)opae_malloc(matches * sizeof(fpga_token));

  num_tokens = matches;
  ASSERT_EQ(fpgaEnumerate(&filter, 1, tokens, num_tokens, &matches), FPGA_OK);

  strcpy(zero, "fpgainfo");
  strcpy(one, "bmc");
  EXPECT_EQ(bmc_command(tokens, num_tokens, 2, argv), FPGA_OK);

  for (uint32_t i = 0; i < num_tokens; ++i) {
    fpgaDestroyToken(&tokens[i]);
  }
  opae_free(tokens);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       bmc_command1
 * @brief      Test: bmc_command
 * @details    When passed with '-h', the fn prints <br>
 *             bmc help message and returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, bmc_command1) {
  char zero[20];
  char one[20];
  char two[20];
  char *argv[] = { zero, one, two, NULL };

  fpga_token *tokens = NULL;

  strcpy(zero, "fpgainfo");
  strcpy(one, "bmc");
  strcpy(two, "-h");
  EXPECT_EQ(bmc_command(tokens, 0, 3, argv), FPGA_OK);
}

/**
 * @test       bmc_command2
 * @brief      Test: bmc_command
 * @details    When passed with invalid '-xyz', the fn prints <br>
 *             bmc help message and returns FPGA_INVALID_PARAM. <br>
 */
TEST_P(fpgainfo_c_p, bmc_command2) {
  char zero[20];
  char one[20];
  char two[20];
  char *argv[] = { zero, one, two, NULL };

  fpga_token *tokens = NULL;

  strcpy(zero, "fpgainfo");
  strcpy(one, "bmc");
  strcpy(two, "-xyz");
  EXPECT_EQ(bmc_command(tokens, 0, 3, argv), FPGA_INVALID_PARAM);
}

/**
 * @test       bmc_help
 * @brief      Test: bmc_help
 * @details    The function prints help message for bmc subcommand.<br>
 */
TEST_P(fpgainfo_c_p, bmc_help) {
  bmc_help();
}

/**
 * @test     events_filter
 * @brief    Test: events_filter
 * @detault  Verify that events_filter doesn't fail
 */
TEST_P(fpgainfo_c_p, events_filter) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };
  fpga_properties filter = NULL;

  strcpy(zero, "fpgainfo");
  strcpy(one, "events");

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  EXPECT_EQ(events_filter(&filter, 2, argv), FPGA_OK);
  ASSERT_EQ(fpgaDestroyProperties(&filter), FPGA_OK);
}

/**
 * @test     events_command0
 * @brief    Test: events_command0
 * @details  Parse valid arguments to events_command (but no tokens) to
 *           verify parsing.
 */
TEST_P(fpgainfo_c_p, events_command0) {
  const char *args[] = {
      "fpgainfo",
      "events",
      "--boot=1",
      "--count=3",
      "--sensors",
      "--bits",
      "--all",
  };
  char *argv[ARRAY_SIZE(args)];
  size_t i;

  /* copy args to make them non-const */
  for (i = 0; i < ARRAY_SIZE(args); i++)
    argv[i] = opae_strdup(args[i]);

  EXPECT_EQ(events_command(NULL, 0, ARRAY_SIZE(argv), argv), FPGA_OK);

  for (i = 0; i < ARRAY_SIZE(args); i++)
    opae_free(argv[i]);
}

/**
 * @test     events_command1
 * @brief    Test: events_command1
 * @details  Pass --help to events command and verify it returns FPGA_OK
 *           verify parsing.
 */
TEST_P(fpgainfo_c_p, events_command1) {
  const char *args[] = {
      "fpgainfo",
      "events",
      "--help",
  };
  char *argv[ARRAY_SIZE(args)];
  size_t i;

  /* copy args to make them non-const */
  for (i = 0; i < ARRAY_SIZE(args); i++)
    argv[i] = opae_strdup(args[i]);

  EXPECT_EQ(events_command(NULL, 0, ARRAY_SIZE(argv), argv), FPGA_OK);

  for (i = 0; i < ARRAY_SIZE(args); i++)
    opae_free(argv[i]);
}

/**
 * @test     events_command2
 * @brief    Test: events_command2
 * @details  Parse invalid arguments to events_command (but no tokens) to
 *           verify expected failure.
 */
TEST_P(fpgainfo_c_p, events_command2) {
  const char *args[] = {
      "fpgainfo",
      "events",
      "",
  };
  const char *invalids[] = {
      "--unknown",
      "--boot=123nan56",
      "--count=nan123",
  };
  char *argv[ARRAY_SIZE(args)];
  size_t i;

  /* copy args to make them non-const */
  for (i = 0; i < ARRAY_SIZE(args); i++)
    argv[i] = opae_strdup(args[i]);

  for (i = 0; i < ARRAY_SIZE(invalids); i++) {
    const size_t arg = ARRAY_SIZE(argv) - 1;

    /* replace last argument with an invalid one */
    opae_free(argv[arg]);
    argv[arg] = opae_strdup(invalids[i]);

    /* reset option index to prepare for (re)parsing arguments */
    optind = 0;

    EXPECT_EQ(events_command(NULL, 0, ARRAY_SIZE(argv), argv), FPGA_INVALID_PARAM);
  }

  for (i = 0; i < ARRAY_SIZE(args); i++)
    opae_free(argv[i]);
}

/**
 * @test     events_help
 * @brief    Test: events_help
 * @details  The function prints help message for events subcommand.<br>
 */
TEST_P(fpgainfo_c_p, events_help) {
  events_help();
}

/**
 * @test       get_metrics0
 * @brief      Test: get_metrics
 * @details    When passed with valid arguments, the fn <br>
 *             retrieve required information from BMC and <br>
 *             returns FPGA_OK. <br>
 */

TEST_P(fpgainfo_c_p, get_metrics0) {
  fpga_properties filter = NULL;
  fpga_token token;
  fpga_metric_info metrics_info[64];
  fpga_metric metrics[64];
  uint64_t num_metrics;
  uint64_t num_metrics_info;
  uint32_t matches = 0;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, &token, 1, &matches), FPGA_OK);

  EXPECT_EQ(get_metrics(token, FPGA_ALL, metrics_info, &num_metrics_info, metrics, &num_metrics), FPGA_OK);

  fpgaDestroyToken(&token);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       get_metrics1
 * @brief      Test: get_metrics
 * @details    When passed with valid arguments, the fn <br>
 *             retrieve required information from BMC and <br>
 *             returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, get_metrics1) {
  fpga_properties filter = NULL;
  fpga_token token;
  fpga_metric_info metrics_info[64];
  fpga_metric metrics[64];
  uint64_t num_metrics;
  uint64_t num_metrics_info;
  uint32_t matches = 0;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, &token, 1, &matches), FPGA_OK);

  EXPECT_EQ(get_metrics(token, FPGA_POWER, metrics_info, &num_metrics_info, metrics, &num_metrics), FPGA_OK);

  fpgaDestroyToken(&token);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       get_metrics2
 * @brief      Test: get_metrics
 * @details    When passed with valid arguments, the fn <br>
 *             retrieve required information from BMC and <br>
 *             returns FPGA_OK. <br>
 */
TEST_P(fpgainfo_c_p, get_metrics2) {
  fpga_properties filter = NULL;
  fpga_token token;
  fpga_metric_info metrics_info[64];
  fpga_metric metrics[64];
  uint64_t num_metrics;
  uint64_t num_metrics_info;
  uint32_t matches = 0;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, &token, 1, &matches), FPGA_OK);

  EXPECT_EQ(get_metrics(token, FPGA_THERMAL, metrics_info, &num_metrics_info, metrics, &num_metrics), FPGA_OK);

  fpgaDestroyToken(&token);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       fpgainfo_print_common
 * @brief      Test: fpgainfo_print_common
 */
TEST_P(fpgainfo_c_p, fpgainfo_print_common) {
  fpga_properties filter = NULL;
  fpga_token token = nullptr;
  uint32_t matches = 0;;

  ASSERT_EQ(fpgaGetProperties(NULL, &filter), FPGA_OK);
  ASSERT_EQ(fpgaPropertiesSetObjectType(filter,FPGA_DEVICE), FPGA_OK);
  ASSERT_EQ(fpgaEnumerate(&filter, 1, &token, 1, &matches), FPGA_OK);

  fpgainfo_print_common("//****** HEADER ******//", filter);

  fpgaDestroyToken(&token);
  fpgaDestroyProperties(&filter);
}

/**
 * @test       fpgainfo_print_err
 * @brief      Test: fpgainfo_print_err
 */
TEST_P(fpgainfo_c_p, fpgainfo_print_err) {
  fpgainfo_print_err("ERROR:", FPGA_INVALID_PARAM);
  fpgainfo_print_err("ERROR:", FPGA_BUSY);
  fpgainfo_print_err("ERROR:", FPGA_EXCEPTION);
  fpgainfo_print_err("ERROR:", FPGA_NOT_FOUND);
  fpgainfo_print_err("ERROR:", FPGA_NO_MEMORY);
  fpgainfo_print_err("ERROR:", FPGA_NOT_SUPPORTED);
  fpgainfo_print_err("ERROR:", FPGA_NO_DRIVER);
  fpgainfo_print_err("ERROR:", FPGA_NO_DAEMON);
  fpgainfo_print_err("ERROR:", FPGA_NO_ACCESS);
  fpgainfo_print_err("ERROR:", FPGA_NO_ACCESS);
}

/**
 * @test       replace_chars0
 * @brief      Test: replace_chars
 */
TEST(fpgainfo_c, replace_chars0) {
  char input[256];
  strcpy(input, "one_two_three_four");
  replace_chars(input, '_', ' ');
  EXPECT_STREQ(input, "one two three four");
}

/**
 * @test       replace_chars1
 * @brief      Test: replace_chars
 */
TEST(fpgainfo_c, replace_chars1) {
  char input[256];
  strcpy(input, "one_two_three_four");
  replace_chars(input, ':', ' ');
  EXPECT_STREQ(input, "one_two_three_four");
}

/**
 * @test       upcase_pci0
 * @brief      Test: upcase_pci
 */
TEST(fpgainfo_c, upcase_pci0) {
  char input[256];
  strcpy(input, "pcie 0");
  upcase_pci(input);
  EXPECT_STREQ(input, "PCIe 0");
}

/**
 * @test       upcase_pci1
 * @brief      Test: upcase_pci
 */
TEST(fpgainfo_c, upcase_pci1) {
  char input[256];
  strcpy(input, "  pcie 0 pcie 1 pcie 2  ");
  upcase_pci(input);
  EXPECT_STREQ(input, "  PCIe 0 PCIe 1 PCIe 2  ");
}

/**
 * @test       upcase_pci2
 * @brief      Test: upcase_pci
 */
TEST(fpgainfo_c, upcase_pci2) {
  char input[256];
  strcpy(input, " pc ");
  upcase_pci(input);
  EXPECT_STREQ(input, " pc ");
}

/**
 * @test       upcase_first0
 * @brief      Test: upcase_first
 */
TEST(fpgainfo_c, upcase_first0) {
  char input[256];
  strcpy(input, "one two three four");
  upcase_first(input);
  EXPECT_STREQ(input, "One Two Three Four");
}

/**
 * @test       upcase_first1
 * @brief      Test: upcase_first
 */
TEST(fpgainfo_c, upcase_first1) {
  char input[256];
  strcpy(input, "One Two Three Four");
  upcase_first(input);
  EXPECT_STREQ(input, "One Two Three Four");
}

/**
 * @test       upcase_first2
 * @brief      Test: upcase_first
 */
TEST(fpgainfo_c, upcase_first2) {
  char input[256] = { 0 };
  strcpy(input, "");
  upcase_first(input);
  EXPECT_STREQ(input, "");
}

/**
 * @test       str_in_list0
 * @brief      Test: upcase_first
 */
TEST(fpgainfo_c, str_in_list0) {
  const char *slist[] = { "one", "two", "two", "three", "four" };
  int idx = str_in_list("one", slist, 5);
  EXPECT_EQ(idx, 0);

  idx = str_in_list("two", slist, 5);
  EXPECT_EQ(idx, 1);

  idx = str_in_list("three", slist, 5);
  EXPECT_EQ(idx, 3);

  idx = str_in_list("four", slist, 5);
  EXPECT_EQ(idx, 4);

  idx = str_in_list("five", slist, 5);
  EXPECT_EQ(idx, INT_MAX);
}

/**
 * @test       parse_args0
 * @brief      Test: parse_args
 * @details    When passed with valid command options, <br>
 *             the fn returns 0. <br>
 */
TEST_P(fpgainfo_c_p, parse_args0) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  strcpy(zero, "fpgainfo");
  strcpy(one, "fme");
  EXPECT_EQ(parse_args(2, argv), 0);

  strcpy(one, "port");
  EXPECT_EQ(parse_args(2, argv), 0);

  strcpy(one, "power");
  EXPECT_EQ(parse_args(2, argv), 0);

  strcpy(one, "temp");
  EXPECT_EQ(parse_args(2, argv), 0);
}

/**
 * @test       parse_args1
 * @brief      Test: parse_args
 * @details    When passed with '-h' or '--help', the fn <br>
 *             prints help message and return non-zero. <br>
 */
TEST_P(fpgainfo_c_p, parse_args1) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  strcpy(zero, "fpgainfo");
  strcpy(one, "-h");
  EXPECT_NE(parse_args(2, argv), 0);

  optind = 0;
  strcpy(one, "--help");
  EXPECT_NE(parse_args(2, argv), 0);
}

/**
 * @test       parse_args2
 * @brief      Test: parse_args
 * @details    When passed with invalid options, the fn <br>
 *             prints error message and return zero. <br>
 */
TEST_P(fpgainfo_c_p, parse_args2) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  strcpy(zero, "fpgainfo");
  strcpy(one, "?");
  EXPECT_EQ(parse_args(2, argv), 0);
}

/**
 * @test       parse_args3
 * @brief      Test: parse_args
 * @details    When passed with an invalid options, the fn <br>
 *             returns zero. <br>
 */
TEST_P(fpgainfo_c_p, parse_args3) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  strcpy(zero, "fpgainfo");
  strcpy(one, "κόσμε");

  /* FIXME: Parse_arg will return 0 on all inputs
            that doesn't match MAIN_GETOPT_STRING.
            Main fails on get_command call but
            will return 0.

  */
  EXPECT_EQ(parse_args(2, argv), 0);
  EXPECT_EQ(fpgainfo_main(2, argv), 0);

  strcpy(one, "\x00 \x09\x0A\x0D\x20\x7E");

  EXPECT_EQ(parse_args(2, argv), 0);
  EXPECT_EQ(fpgainfo_main(2, argv), 0);
}

/**
 * @test       help
 * @brief      Test: help
 * @details    help displays the application help message.<br>
 */
TEST_P(fpgainfo_c_p, help) {
  help();
}

/**
 * @test       main_1
 * @brief      Test: fpgainfo_main
 * @details    When passed with no argument, the fn <br>
 *             returns an error. <br>
 */
TEST_P(fpgainfo_c_p, main_1) {
  char zero[20];
  char *argv[] = { zero, NULL };

  strcpy(zero, "fpgainfo");

  EXPECT_NE(fpgainfo_main(1, argv), 0);
}

/**
 * @test       main_2
 * @brief      Test: fpgainfo_main
 * @details    When passed with the version option, the fn <br>
 *             returns zero. <br>
 */
TEST_P(fpgainfo_c_p, main_2) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  strcpy(zero, "fpgainfo");
  strcpy(one, "-v");

  EXPECT_EQ(fpgainfo_main(2, argv), 0);
}

/**
 * @test       main_3
 * @brief      Test: fpgainfo_main
 * @details    When missing an argument, the fn <br>
 *             returns an error. <br>
 */
TEST_P(fpgainfo_c_p, main_3) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  strcpy(zero, "fpgainfo");
  strcpy(one, "-B");

  EXPECT_NE(fpgainfo_main(2, argv), 0);
}

/**
 * @test       main_4
 * @brief      Test: fpgainfo_main
 * @details    When passed with invalid option, the fn <br>
 *             returns an error. <br>
 */
TEST_P(fpgainfo_c_p, main_4) {
  char zero[20];
  char one[20];
  char *argv[] = { zero, one, NULL };

  strcpy(zero, "fpgainfo");
  strcpy(one, "-K");

  EXPECT_NE(fpgainfo_main(2, argv), 0);
}

/**
 * @test       main_5
 * @brief      Test: fpgainfo_main
 * @details    When passed with valid option, the fn <br>
 *             returns 0. <br>
 */
TEST_P(fpgainfo_c_p, main_5) {
  char zero[20];
  char one[20];
  char two[20];
  char three[20];
  char *argv[] = { zero, one, two, three, NULL };
  char bus[10];

  sprintf(bus, "0x%x", platform_.devices[0].bus);

  strcpy(zero, "fpgainfo");
  strcpy(one, "fme");
  strcpy(two, "-B");
  strcpy(three, bus);

  EXPECT_EQ(fpgainfo_main(4, argv), 0);
}

/**
 * @test       main_6
 * @brief      Test: fpgainfo_main
 * @details    When passed with invalid option, the fn <br>
 *             returns an error. <br>
 */
TEST_P(fpgainfo_c_p, main_6) {
  char zero[20];
  char one[20];
  char two[20];
  char three[20];
  char *argv[] = { zero, one, two, three, NULL };

  strcpy(zero, "fpgainfo");
  strcpy(one, "fme");
  strcpy(two, "-B");
  strcpy(three, "0xFF");

  EXPECT_NE(fpgainfo_main(4, argv), 0);
}

/**
 * @test       main_7
 * @brief      Test: fpgainfo_main
 * @details    When passed with valid option, the fn <br>
 *             returns 0. <br>
 */
TEST_P(fpgainfo_c_p, main_7) {
  char zero[20];
  char one[20];
  char two[20];
  char *argv[] = { zero, one, two, NULL };

  strcpy(zero, "fpgainfo");
  strcpy(one, "fme");
  strcpy(two, "--verbose");

  EXPECT_EQ(fpgainfo_main(3, argv), 0);
}

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(fpgainfo_c_p);
INSTANTIATE_TEST_SUITE_P(fpgainfo_c, fpgainfo_c_p,
                         ::testing::ValuesIn(test_platform::platforms({ "dfl-n3000" })));
